/**
 * 后半部分一样，只是前面判前后缀回文的方法改为后缀数组。
 * 对于字符串S问S[0...i]是否为回文，
 * 首项将S倒过来接在S后面，记作SS，然后求出SS的Height数组。
 * 取后缀0的排名为a，取后缀N+N-i的排名为b，
 * 则如果Height[a+1...b]的区间最小值大于等于i+1就说嘛该前缀是回文。
 * 判后缀是否回文有类似方法。
 * 所以先求出后缀数组，再对Height数组用一个SparseTable算法。
 * 然后对每个前、后缀进行判断
 */
#include <bits/stdc++.h>
using namespace std;

using llt = long long;
using vi = vector<int>;

template<typename IT = vector<int>::const_iterator>
struct SparseTable{

using T = pair<int, int>;
using vt = vector<T>; 
using vvt = vector<vt>;

// SparseTable() = delete;

IT head;
vvt data;

/// 从s开始的n个数，作为原始数组，建立ST表，索引从0开始
/// 整个ST期间，原始数组的内容不能改变
SparseTable(IT begin, int n):head(begin){
    data.assign(n, vt());

    for(int i=0;i<n;++i) {
		data[i].reserve(21); // 100w用21即可
		data[i].emplace_back(i, i);
	}

	for(int j=1,t;(t=1<<j)<=n;++j){
        for(int i=0;i+t<=n;++i){
			const auto & prv = data[i][j-1];
			const auto & nxt = data[i+(t>>1)][j-1];

			auto first = *(begin + prv.first) <= *(begin + nxt.first) ? prv.first : nxt.first;
			auto second = *(begin + nxt.second) <= *(begin + prv.second) ? prv.second : nxt.second;

			data[i].emplace_back(first, second);
		} 
	}

	return;
}

/// 查询[s, e]区间的极小极大值所在的下标，即距离构造函数begin的偏移量
/// 索引从0开始
T query(int s, int e)const{
    int k = static_cast<int>(log2((double)(e - s + 1)));
	const auto & p1 = data[s][k];
	const auto & p2 = data[e-(1<<k)+1][k];
    return {
        *(head + p1.first) <= *(head + p2.first) ? p1.first : p2.first,
		*(head + p2.second) <= *(head + p1.second) ? p1.second : p2.second 
	};
}


};

struct SuffixArray{

using vi = vector<int>;

// 从i位置开始的后缀记作后缀i,i从0开始
const vi & r;
const int mm;

vi sa;    // 排名第i为的后缀是sa[i]，排名从0开始，因此sa[0]总是n-1
vi rank;  // 后缀i的排名是rank[i]，排名从0开始，因此rank[n-1]总是0
vi height; // height[i]表示排名第i-1和第i的后缀的公共前缀的长度，height[0]和heigth[1]总是0

/// source是源数组，最好令结尾是最小的元素，其余则大于0
/// m为r中不同取值的数量
SuffixArray(const vi & source, int m):r(source), mm(m){
    da(); 
	calHeight();
}

void da(){ // 倍增
    int n = r.size();
	int m = mm;
    sa.assign(n, 0);

	assert(0 == r[n-1]);
	for(int i=0;i<n-1;++i) assert(0 < r[i] && r[i] < m);

    _ws.assign(max(n, m), 0); // 桶的数量是多少？
	_wv.assign(n, 0);
	_wa.assign(n, 0);
	_wb.assign(n, 0);

	// auto * x = _wa.data();
	// auto * y = _wb.data();
	auto x = _wa.begin();
	auto y = _wb.begin();

	int i,j,p;
    // for(i=0;i<m;i++) _ws[i] = 0;
    for(i=0;i<n;i++) _ws[x[i] = r[i]]++;
    for(i=1;i<m;i++) _ws[i] += _ws[i-1];
    for(i=n-1;i>=0;i--) sa[--_ws[*(x+i)]]=i;
    for(j=1,p=1;p<n;j<<=1,m=p){
        for(p=0,i=n-j;i<n;i++) *(y+p++)=i;
        for(i=0;i<n;i++) if(sa[i]>=j) *(y+p++)=sa[i]-j;
        for(i=0;i<n;i++) _wv[i]=*(x+*(y+i));
        fill(_ws.begin(), _ws.begin()+m, 0);
        for(i=0;i<n;i++) _ws[_wv[i]]++;
        for(i=1;i<m;i++) _ws[i] += _ws[i-1];
        for(i=n-1;i>=0;i--) sa[--_ws[_wv[i]]] = *(y+i);
		for(swap(x, y),p=1,*(x+sa[0])=0,i=1;i<n;i++){
            *(x+sa[i])=_cmp(y,sa[i-1],sa[i],j)?p-1:p++;
		}
    }
    return;
}

void calHeight(){
	int n = sa.size();
	rank.assign(n, 0);
	height.assign(n, 0);
	int k = 0;
    for(int i=0;i<n;++i) rank[sa[i]] = i;
	for(int i=0,j;i<n-1;height[rank[i++]] = k){
		for(k ? k-- : 0, j=sa[rank[i] - 1]; r[i + k] == r[j + k]; ++k);
	}
	return;
}

int _cmp(vi::iterator x, int a, int b, int l){
	return *(x+a) == *(x+b) &&  a + l < r.size() && b + l < r.size() &&  *(x+a+l) == *(x+b+l);
}

vi _wa, _wb;
vi _wv, _ws;


};

int N, M;
string S, T;

bool check(
    int n, int sp, const SuffixArray & ssa, const SparseTable<vi::const_iterator> & sst,
    int m, int tp, const SuffixArray & tsa, const SparseTable<vi::const_iterator> & tst
){
    array<int, 2> pos;
    int offset = n - sp;
    /// 取对应的后缀排名
    pos[0] = ssa.rank[0];
    pos[1] = ssa.rank[n + n - sp];
    sort(pos.begin(), pos.end());
    /// 取height的极小值
    auto pp = sst.query(pos[0] + 1, pos[1]);
    /// 如果小于说明不是回文
    if(*(ssa.height.begin() + pp.first) < sp + 1) return false;

    offset = m - tp;
    pos[0] = tsa.rank[tp];
    pos[1] = tsa.rank[m + 1];
    sort(pos.begin(), pos.end());
    /// 取height的极小值
    pp = tst.query(pos[0] + 1, pos[1]);
    /// 如果小于说明不是回文
    if(*(tsa.height.begin() + pp.first) < offset) return false;

    return true;
}

int proc(){
    vi svec(N + 1 + N + 1, 0);
    for(int i=0;i<N;++i) svec[i] = svec[N + N - i] = S[i] - 'a' + 1;
    svec[N] = 27;    
    SuffixArray ssa(svec, 28);
    SparseTable<vi::const_iterator> sst(ssa.height.begin(), ssa.height.size());

    vi tvec(M + 1 + M + 1, 0);
    for(int i=0;i<M;++i) tvec[i] = tvec[M + M - i] = T[i] - 'a' + 1;
    tvec[M] = 27;
    SuffixArray tsa(tvec, 28);
    SparseTable<vi::const_iterator> tst(tsa.height.begin(), tsa.height.size());

    vector<int> pre;
    for(int i=0,j=M-1;i<N&&j>=0;++i,--j){
        if(S[i] != T[j]) break;
        if(check(N, i, ssa, sst, M, j, tsa, tst)){
            pre.emplace_back(i);
        }
    }

    if(pre.empty()) return -1;

    vector<int> suf;
    for(int j=0,i=N-1;i>=0&&j<M;++j,--i){
        if(S[i] != T[j]) break;
        if(check(M, j, tsa, tst, N, i, ssa, sst)){
            suf.push_back(i);
        }
    }

    if(suf.empty()) return -1;
    reverse(suf.begin(), suf.end());

    int limit = min(N, M);
    int ans = -1;
    for(auto i : pre){
        auto pp = equal_range(suf.begin(), suf.end(), N + i + 1 - limit);
        if(pp.first != pp.second){
            auto t = *pp.first;
            int tmp = i + 1 + N - t;
            if(-1 == ans or ans < tmp){
                ans = tmp;
            }
        }else if(pp.second != suf.end()){
            auto t = *pp.second;
            int tmp = i + 1 + N - t;
            if(-1 == ans or ans < tmp){
                ans = tmp;
            }
        }
    }
    return ans + ans;
}


int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int nofkase = 1; 
    // cin >> nofkase;
    while(nofkase--){
        cin >> N >> M >> S >> T;
        cout << proc() << "\n";
    }
    return 0;
}